webknossos-datastore/app/com/scalableminds/webknossos/datastore/services/mesh/FullMeshHelper.scala (1)

78-114: Surface area calculation looks correct, consider adding input validation.

The algorithm correctly computes surface area from STL binary format:

• Proper parsing of STL structure (80-byte header, 4-byte triangle count, 50 bytes per triangle)
• Correct triangle area calculation using cross product magnitude divided by 2
• Appropriate error handling with tryo

Consider adding input validation to make the algorithm more robust against malformed data:

 def surfaceAreaFromStlBytes(stlBytes: Array[Byte]): Box[Float] = tryo {
   val dataBuffer = ByteBuffer.wrap(stlBytes)
   dataBuffer.order(ByteOrder.LITTLE_ENDIAN)
+  if (stlBytes.length < 84) {
+    throw new IllegalArgumentException(s"STL data too short: ${stlBytes.length} bytes, minimum 84 bytes required")
+  }
   val numberOfTriangles = dataBuffer.getInt(80)
+  val expectedSize = 84 + numberOfTriangles * 50
+  if (stlBytes.length < expectedSize) {
+    throw new IllegalArgumentException(s"STL data incomplete: expected $expectedSize bytes, got ${stlBytes.length}")
+  }
   val normalOffset = 12
   var surfaceSumMutable = 0.0f
   val headerOffset = 84
   val bytesPerTriangle = 50

frontend/javascripts/viewer/model/accessors/volumetracing_accessor.ts (1)

951-960: Return mapping only when enabled to avoid using disabled mappings

Currently, a disabled mapping can be returned. Prefer honoring mappingStatus and return null/undefined when not ENABLED.

Apply this refinement:

 export function getCurrentMappingName(state: WebknossosState) {
   const visibleSegmentationLayer = getVisibleSegmentationLayer(state);
   const volumeTracing = getActiveSegmentationTracing(state);
   if (volumeTracing?.mappingName != null) return volumeTracing?.mappingName;
   const mappingInfo = getMappingInfo(
     state.temporaryConfiguration.activeMappingByLayer,
     visibleSegmentationLayer?.name,
   );
-  return mappingInfo.mappingName;
+  return mappingInfo.mappingStatus === MappingStatusEnum.ENABLED
+    ? mappingInfo.mappingName
+    : null;
 }

webknossos-tracingstore/app/com/scalableminds/webknossos/tracingstore/TSRemoteWebknossosClient.scala (1)

58-58: Bound the voxel size cache to avoid unbounded growth

Consider adding a maxCapacity similar to annotationIdByTracingIdCache to prevent unbounded entries during long‑running servers.

-  private lazy val voxelSizeCache: AlfuCache[ObjectId, VoxelSize] = AlfuCache(timeToLive = 10 minutes)
+  private lazy val voxelSizeCache: AlfuCache[ObjectId, VoxelSize] =
+    AlfuCache(maxCapacity = 10000, timeToLive = 10 minutes)

frontend/javascripts/viewer/view/context_menu.tsx (2)

1666-1672: Harden refresh action with error handling

Persist may fail; keep the menu usable and inform users.

-  const handleRefreshSegmentStatistics = async () => {
-    await api.tracing.save();
-    setSegmentStatsTriggerDate(new Date());
-  };
+  const handleRefreshSegmentStatistics = async () => {
+    try {
+      await api.tracing.save();
+    } catch (e) {
+      Toast.error("Saving the annotation failed. Showing last known statistics.");
+    } finally {
+      setSegmentStatsTriggerDate(new Date());
+    }
+  };

---

1757-1758: Include mappingName in fetch dependencies

Prevents stale stats when the active mapping changes.

-    [contextMenuPosition, isSegmentIndexAvailable, clickedSegmentOrMeshId, segmentStatsTriggerDate],
+    [
+      contextMenuPosition,
+      isSegmentIndexAvailable,
+      clickedSegmentOrMeshId,
+      segmentStatsTriggerDate,
+      mappingName,
+    ],

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

webknossos-datastore/app/com/scalableminds/webknossos/datastore/services/mesh/FullMeshHelper.scala (1)

78-114: Surface area calculation is mathematically correct.

The STL parsing and area computation logic is sound:

• Correctly parses binary STL format (80-byte header + 4-byte count + 50-byte triangles)
• Triangle area via cross product magnitude divided by 2 is accurate
• tryo wraps the computation to handle exceptions

Consider adding a defensive bounds check at the start to fail fast on malformed input:

 def surfaceAreaFromStlBytes(stlBytes: Array[Byte]): Box[Float] = tryo {
   val dataBuffer = ByteBuffer.wrap(stlBytes)
   dataBuffer.order(ByteOrder.LITTLE_ENDIAN)
   val numberOfTriangles = dataBuffer.getInt(80)
+  val expectedMinBytes = 84 + numberOfTriangles * 50
+  if (stlBytes.length < expectedMinBytes) {
+    throw new IllegalArgumentException(s"STL data too short: expected at least $expectedMinBytes bytes, got ${stlBytes.length}")
+  }
   val normalOffset = 12
   ...

This would provide clearer error messages for malformed mesh data rather than generic buffer underflow exceptions.

webknossos-tracingstore/app/com/scalableminds/webknossos/tracingstore/controllers/VolumeTracingController.scala (1)

351-377: Clarify why editableMappingTracingId is set to None
Ad-hoc meshing always goes through loadMeshChunkFromAdHoc, which ignores the request’s editableMappingTracingId and uses annotationService.editableMappingLayer when tracing.hasEditableMapping is true. It’s safe to leave it as None, but please add a brief comment explaining this.

webknossos-tracingstore/app/com/scalableminds/webknossos/tracingstore/TSRemoteWebknossosClient.scala (1)

131-146: Clean cached accessor for voxel size

Nice factoring: cache-backed public method and RPC-based helper with proper token use and Option→Fox lifting. Consider adding a specific error key instead of a string literal for voxelSizeOpt (optional).

frontend/javascripts/viewer/view/right-border-tabs/segments_tab/segment_statistics_modal.tsx (2)

1-1: Import only what you need (optional)

To reduce bundle size, prefer per-method lodash import for capitalize or a small custom capitalize.

-import _ from "lodash";
+import capitalize from "lodash/capitalize";

And adjust usage:

-  const capitalizedUnit = _.capitalize(dataSourceUnit);
+  const capitalizedUnit = capitalize(dataSourceUnit);

---

145-153: Single source of truth for mappingName (optional)

You compute mappingName twice (maybeGetMappingName() and selector mappingName). Use the selector consistently to avoid drift.

-          maybeGetMappingName(),
+          mappingName,

(Apply similarly for bounding boxes.)

Also applies to: 129-130

app/controllers/WKRemoteTracingStoreController.scala (1)

164-172: Add implicit DBAccessContext for consistency.

Other methods in this controller establish an implicit DBAccessContext; consider doing the same here to avoid surprises if DatasetService methods require it later.

 def getDataSource(name: String, key: String, datasetId: ObjectId): Action[AnyContent] =
   Action.async { implicit request =>
-    tracingStoreService.validateAccess(name, key) { _ =>
+    tracingStoreService.validateAccess(name, key) { _ =>
+      implicit val ctx: DBAccessContext = GlobalAccessContext
       for {
-        dataset <- datasetDAO.findOne(datasetId)(GlobalAccessContext) ?~> "dataset.notFound" ~> NOT_FOUND
+        dataset <- datasetDAO.findOne(datasetId)(GlobalAccessContext) ?~> "dataset.notFound" ~> NOT_FOUND
         dataSource <- datasetService.dataSourceFor(dataset)
       } yield Ok(Json.toJson(dataSource))
     }
   }

frontend/javascripts/admin/rest_api.ts (2)

882-888: Include seedPosition in the payload type (parity with backend).

Backend SegmentStatisticsParametersMeshBased supports an optional seedPosition. Add it here to enable ad‑hoc/volume contexts.

 type SegmentStatisticsParametersMeshBased = {
   mag: Vector3;
   segmentIds: number[];
   mappingName?: string | null;
   additionalCoordinates?: AdditionalCoordinate[] | null;
   meshFileName?: string | null;
+  seedPosition?: Vector3 | null;
 };

---

890-914: Pass through seedPosition and optionally accept it in the function signature.

Surface area for volume tracings may require seedPosition. Thread it through now to avoid another API change.

-export function getSegmentSurfaceArea(
-  requestUrl: string,
-  mag: Vector3,
-  meshFileName: string | undefined | null,
-  segmentIds: Array<number>,
-  additionalCoordinates: AdditionalCoordinate[] | undefined | null,
-  mappingName: string | null | undefined,
-): Promise<number[]> {
+export function getSegmentSurfaceArea(
+  requestUrl: string,
+  mag: Vector3,
+  meshFileName: string | undefined | null,
+  segmentIds: Array<number>,
+  additionalCoordinates: AdditionalCoordinate[] | undefined | null,
+  mappingName: string | null | undefined,
+  seedPosition?: Vector3 | null,
+): Promise<number[]> {
   return doWithToken((token) => {
     const data: SegmentStatisticsParametersMeshBased = {
       mag,
       segmentIds,
       mappingName,
       additionalCoordinates,
       meshFileName,
+      seedPosition,
     };
     return Request.sendJSONReceiveJSON(
       `${requestUrl}/segmentStatistics/surfaceArea?token=${token}`,
       {
         data,
         method: "POST",
       },
     );
   });
 }

Would you like me to propagate this through the current callers (segment stats modal/context menu)?

conf/webknossos.latest.routes (1)

111-114: Expose or remove readDataSource.
The controller defines readDataSource (app/controllers/DatasetController.scala:347) but there’s no corresponding GET route—currently GET /datasets/:datasetId calls read. If you intend to expose readDataSource, add a distinct route; otherwise remove the unused action to avoid confusion.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Learnt from: MichaelBuessemeyer
PR: scalableminds/webknossos#8824
File: frontend/javascripts/viewer/view/context_menu.tsx:1033-1039
Timestamp: 2025-09-08T13:33:47.097Z
Learning: In frontend/javascripts/viewer/view/context_menu.tsx, the segmentIdLabel intentionally shows the unmapped segment ID (maybeUnmappedSegmentId) in the "within Segment ${id}" text when proofreading is active, as this can be helpful for users. The mapped segment ID (segmentIdAtPosition) is only used as a fallback when the unmapped ID is not available.

webknossos-tracingstore/app/com/scalableminds/webknossos/tracingstore/TSRemoteWebknossosClient.scala (1)

135-145: Consider enhancing the error message with context.

The implementation is correct, but the error message on line 144 could be more informative for debugging by including the annotationId or datasetId.

Apply this diff to enhance the error message:

     for {
       datasetId <- getDatasetIdForAnnotation(annotationId)
       result <- rpc(s"$webknossosUri/api/tracingstores/$tracingStoreName/datasources/$datasetId")
         .addQueryString("key" -> tracingStoreKey)
         .withTokenFromContext
         .silent
         .getWithJsonResponse[DataSource]
-      scale <- result.voxelSizeOpt.toFox ?~> "Could not determine voxel size of dataset"
+      scale <- result.voxelSizeOpt.toFox ?~> s"Could not determine voxel size for annotation $annotationId (dataset $datasetId)"
     } yield scale

app/controllers/WKRemoteDataStoreController.scala (1)

264-266: Use localized message with datasetId for consistency and context.

Prefer passing a resolved Messages(...) with the id to fill the placeholder and align with surrounding code.

-          dataset <- datasetDAO.findOne(datasetId)(GlobalAccessContext) ?~> "dataset.notFound" ~> NOT_FOUND
+          dataset <- datasetDAO.findOne(datasetId)(GlobalAccessContext) ?~> Messages("dataset.notFound", datasetId) ~> NOT_FOUND

webknossos-datastore/app/com/scalableminds/webknossos/datastore/services/mesh/FullMeshHelper.scala (1)

78-114: Improve numerical robustness (Double accumulation, skip NaN/Infinity).

• Accumulate in Double to reduce precision loss on large meshes.
• Ignore degenerate/invalid triangles that produce NaN/Infinity.

-  def surfaceAreaFromStlBytes(stlBytes: Array[Byte]): Box[Float] = tryo {
+  def surfaceAreaFromStlBytes(stlBytes: Array[Byte]): Box[Float] = tryo {
     val dataBuffer = ByteBuffer.wrap(stlBytes)
     dataBuffer.order(ByteOrder.LITTLE_ENDIAN)
     val numberOfTriangles = dataBuffer.getInt(80)
     val normalOffset = 12
-    var surfaceSumMutable = 0.0f
+    var surfaceSumMutable = 0.0d
     val headerOffset = 84
     val bytesPerTriangle = 50
     for (triangleIndex <- 0 until numberOfTriangles) {
       val triangleVerticesOffset = headerOffset + triangleIndex * bytesPerTriangle + normalOffset
       val v1x = dataBuffer.getFloat(triangleVerticesOffset + 4 * 0)
       val v1y = dataBuffer.getFloat(triangleVerticesOffset + 4 * 1)
       val v1z = dataBuffer.getFloat(triangleVerticesOffset + 4 * 2)
       val v2x = dataBuffer.getFloat(triangleVerticesOffset + 4 * 3)
       val v2y = dataBuffer.getFloat(triangleVerticesOffset + 4 * 4)
       val v2z = dataBuffer.getFloat(triangleVerticesOffset + 4 * 5)
       val v3x = dataBuffer.getFloat(triangleVerticesOffset + 4 * 6)
       val v3y = dataBuffer.getFloat(triangleVerticesOffset + 4 * 7)
       val v3z = dataBuffer.getFloat(triangleVerticesOffset + 4 * 8)

       val vec1x = v2x - v1x
       val vec1y = v2y - v1y
       val vec1z = v2z - v1z
       val vec2x = v3x - v1x
       val vec2y = v3y - v1y
       val vec2z = v3z - v1z

       val crossx = vec1y * vec2z - vec1z * vec2y
       val crossy = vec1z * vec2x - vec1x * vec2z
       val crossz = vec1x * vec2y - vec1y * vec2x

-      val magnitude = Math.sqrt(crossx * crossx + crossy * crossy + crossz * crossz).toFloat
-
-      surfaceSumMutable = surfaceSumMutable + (magnitude / 2.0f)
+      val magnitude = math.sqrt(
+        crossx.toDouble * crossx.toDouble +
+        crossy.toDouble * crossy.toDouble +
+        crossz.toDouble * crossz.toDouble
+      )
+      if (!magnitude.isNaN && !magnitude.isInfinite) {
+        surfaceSumMutable += magnitude / 2.0
+      }
     }
-    surfaceSumMutable
+    surfaceSumMutable.toFloat
   }

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

frontend/javascripts/admin/rest_api.ts (1)

882-888: Missing seedPosition in payload breaks tracingstore ad‑hoc meshing

The tracingstore endpoint requires a seed to build ad‑hoc meshes. The TS type and payload omit it, so volume annotations will fail.

Apply this diff:

 type SegmentStatisticsParametersMeshBased = {
   mag: Vector3;
   segmentIds: number[];
   mappingName?: string | null;
   additionalCoordinates?: AdditionalCoordinate[] | null;
   meshFileName?: string | null;
+  seedPosition?: Vector3 | null;
 };

 export function getSegmentSurfaceArea(
   layerSourceInfo: LayerSourceInfo,
   mag: Vector3,
   meshFileName: string | undefined | null,
   segmentIds: Array<number>,
   additionalCoordinates: AdditionalCoordinate[] | undefined | null,
   mappingName: string | null | undefined,
+  seedPosition?: Vector3 | null | undefined,
 ): Promise<number[]> {
   const requestUrl = getDataOrTracingStoreUrl(layerSourceInfo);
   return doWithToken((token) => {
     const data: SegmentStatisticsParametersMeshBased = {
       mag,
       segmentIds,
       mappingName,
       additionalCoordinates,
       meshFileName,
+      seedPosition,
     };
     return Request.sendJSONReceiveJSON(
       `${requestUrl}/segmentStatistics/surfaceArea?token=${token}`,
       {
         data,
         method: "POST",
       },
     );
   });
 }

#!/bin/bash
# Find and show all call sites to update with the new seedPosition argument.
rg -n --type=ts -C2 '\bgetSegmentSurfaceArea\s*\('

Also applies to: 890-915

frontend/javascripts/viewer/view/right-border-tabs/segments_tab/segment_statistics_modal.tsx (1)

31-34: CSV header typo: “segmendId” → “segmentId”

Fix the column name.

-  return `segmendId,segmentName,groupId,groupName,volumeInVoxel,volumeIn${capitalizedUnit}3,surfaceAreaIn${capitalizedUnit}2,boundingBoxTopLeftPositionX,boundingBoxTopLeftPositionY,boundingBoxTopLeftPositionZ,boundingBoxSizeX,boundingBoxSizeY,boundingBoxSizeZ`;
+  return `segmentId,segmentName,groupId,groupName,volumeInVoxel,volumeIn${capitalizedUnit}3,surfaceAreaIn${capitalizedUnit}2,boundingBoxTopLeftPositionX,boundingBoxTopLeftPositionY,boundingBoxTopLeftPositionZ,boundingBoxSizeX,boundingBoxSizeY,boundingBoxSizeZ`;

frontend/javascripts/viewer/view/context_menu.tsx (1)

1899-1938: Duplicate keys in info items

Both rows use key "volumeInfo". Make keys unique.

-      getInfoMenuItem(
-        "volumeInfo",
+      getInfoMenuItem(
+        "surfaceAreaInfo",
         <>
           <i className="segment-context-icon">m²</i>
           Surface Area: {segmentSurfaceAreaLabel}
           {copyIconWithTooltip(segmentSurfaceAreaLabel as string, "Copy surface area")}
         </>,
       ),

frontend/javascripts/viewer/view/right-border-tabs/segments_tab/segment_statistics_modal.tsx (1)

136-143: Use the same mappingName source for all three requests

Surface area uses mappingName while volume/bbox use maybeGetMappingName(). Align them to avoid mismatches.

-          mappingName,
+          maybeGetMappingName(),

Also applies to: 160-167

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

frontend/javascripts/viewer/view/right-border-tabs/segments_tab/segment_statistics_modal.tsx (2)

33-33: Fix CSV header typo: "segmendId" → "segmentId".

This typo was flagged in a previous review but remains unfixed.

-  return `segmendId,segmentName,groupId,groupName,volumeInVoxel,volumeIn${capitalizedUnit}3,surfaceAreaIn${capitalizedUnit}2,boundingBoxTopLeftPositionX,boundingBoxTopLeftPositionY,boundingBoxTopLeftPositionZ,boundingBoxSizeX,boundingBoxSizeY,boundingBoxSizeZ`;
+  return `segmentId,segmentName,groupId,groupName,volumeInVoxel,volumeIn${capitalizedUnit}3,surfaceAreaIn${capitalizedUnit}2,boundingBoxTopLeftPositionX,boundingBoxTopLeftPositionY,boundingBoxTopLeftPositionZ,boundingBoxSizeX,boundingBoxSizeY,boundingBoxSizeZ`;

---

160-167: Surface area call may fail for volume annotations without mesh files.

When currentMeshFile is null (e.g., for volume annotations), the backend may reject the request or return invalid results. A previous review flagged that tracingstore endpoints require seedPosition for ad-hoc mesh generation, which this modal doesn't provide.

Wrap the getSegmentSurfaceArea call in a conditional check:

       const segmentStatisticsObjects = await Promise.all([
         getSegmentVolumes(
           storeInfoType,
           layersFinestMag,
           segmentIds,
           additionalCoordinates,
           maybeGetMappingName(),
         ),
         getSegmentBoundingBoxes(
           storeInfoType,
           layersFinestMag,
           segmentIds,
           additionalCoordinates,
           maybeGetMappingName(),
         ),
-        getSegmentSurfaceArea(
-          storeInfoType,
-          layersFinestMag,
-          currentMeshFile?.name,
-          segmentIds,
-          additionalCoordinates,
-          mappingName,
-        ),
+        currentMeshFile
+          ? getSegmentSurfaceArea(
+              storeInfoType,
+              layersFinestMag,
+              currentMeshFile.name,
+              segmentIds,
+              additionalCoordinates,
+              mappingName,
+            )
+          : Promise.resolve(segmentIds.map(() => 0)),
       ]).then(

This ensures surface area is only fetched when a mesh file is available, falling back to zeros for volume annotations. Adjust the UI to indicate when surface area is unavailable if needed.

frontend/javascripts/viewer/view/right-border-tabs/segments_tab/segment_statistics_modal.tsx (1)

7-7: Consider native string capitalization instead of lodash.

Lodash is imported solely for _.capitalize() at line 32. A native alternative removes the dependency:

-import _ from "lodash";

Then at line 32:

-  const capitalizedUnit = _.capitalize(dataSourceUnit);
+  const capitalizedUnit = dataSourceUnit.charAt(0).toUpperCase() + dataSourceUnit.slice(1);

This eliminates the lodash dependency for a trivial operation and reduces bundle size.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

webknossos-datastore/app/com/scalableminds/webknossos/datastore/controllers/DataSourceController.scala (1)

627-643: Fix type comparison and hardcoded mappingType (duplicate from past reviews).

Two critical issues remain unaddressed from previous reviews:

Issue 1 (Line 629): The condition mappingNameForMeshFile.contains(request.body.meshFileName) will always be false. Option.contains() expects a String, but request.body.meshFileName is Option[String]. This causes static mesh files to never be used, forcing ad-hoc meshing even when a valid precomputed mesh file exists.

Issue 2 (Line 633): The mappingType is hardcoded to "HDF5" whenever mappingName exists. For zarr-based mesh files and other formats, this forces DSFullMeshService to use the wrong reader, causing failures.

Apply this diff to fix both issues:

           surfaceAreas <- Fox.serialCombined(request.body.segmentIds) { segmentId =>
+            val useProvidedMesh = meshFileKeyOpt.isDefined &&
+              mappingNameForMeshFile == request.body.mappingName
             val fullMeshRequest = FullMeshRequest(
-              meshFileName =
-                if (mappingNameForMeshFile.contains(request.body.meshFileName)) request.body.meshFileName else None,
+              meshFileName = if (useProvidedMesh) request.body.meshFileName else None,
               lod = None,
               segmentId = segmentId,
               mappingName = request.body.mappingName,
-              mappingType = request.body.mappingName.map(_ => "HDF5"),
+              mappingType = None, // DSFullMeshService will determine the correct type
               editableMappingTracingId = None,
               mag = Some(request.body.mag),
               seedPosition = request.body.seedPosition,
               additionalCoordinates = request.body.additionalCoordinates,
             )

Alternatively, if you need to pass the actual mapping type, derive it from the mesh file key's data format rather than hardcoding it.

webknossos-tracingstore/app/com/scalableminds/webknossos/tracingstore/TSRemoteWebknossosClient.scala (1)

131-145: Parse JSON as UsableDataSource
Replace .getWithJsonResponse[DataSource] with .getWithJsonResponse[UsableDataSource] in voxelSizeForAnnotation to enforce that only usable datasources are deserialized (as in getDataSourceForAnnotation). Confirm the /datasources/$datasetId endpoint never returns an unusable datasource.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

webknossos-tracingstore/app/com/scalableminds/webknossos/tracingstore/TSRemoteWebknossosClient.scala (1)

58-58: Consider caching by datasetId instead of annotationId.

The cache uses annotationId as the key, but voxel size is a dataset property, not an annotation property. Multiple annotations referencing the same dataset will create duplicate cache entries, wasting memory. Since line 138 already retrieves the datasetId, consider refactoring to cache by datasetId for better efficiency.

Example refactor:

-private lazy val voxelSizeCache: AlfuCache[ObjectId, VoxelSize] = AlfuCache(timeToLive = 10 minutes)
+private lazy val voxelSizeByDatasetCache: AlfuCache[ObjectId, VoxelSize] = AlfuCache(timeToLive = 10 minutes)

Then in the public method:

def voxelSizeForAnnotationWithCache(annotationId: ObjectId)(implicit tc: TokenContext,
                                                            ec: ExecutionContext): Fox[VoxelSize] =
  for {
    datasetId <- getDatasetIdForAnnotation(annotationId)
    voxelSize <- voxelSizeByDatasetCache.getOrLoad(datasetId, dId => voxelSizeForDataset(dId))
  } yield voxelSize

private def voxelSizeForDataset(datasetId: ObjectId)(implicit tc: TokenContext,
                                                     ec: ExecutionContext): Fox[VoxelSize] =
  for {
    result <- rpc(s"$webknossosUri/api/tracingstores/$tracingStoreName/datasources/$datasetId")
      .addQueryParam("key", tracingStoreKey)
      .withTokenFromContext
      .silent
      .getWithJsonResponse[DataSource]
    scale <- result.voxelSizeOpt.toFox ?~> "Could not determine voxel size of dataset"
  } yield scale

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro